import {
    isUndef,
} from '@/lib/utils';

/**
 * 分割字符串
 *
 * @param {string} str
 * @param {array} keywords
 *
 * tip: 传入的keywords数组不会被修改
 *
 * @return {Array} 最终将字符串分割成一个array的结果
 */
export function split(str, keywords) {
    const result = [];
    /** 所有当前的下标位置 */
    const positions = {};
    const strlen = str.length;
    /** 检索下标 */
    let position = 0;
    const keywordsCopy = keywords.slice(0);

    keywordsCopy.forEach((keyword) => {
        const pos = str.indexOf(keyword);
        if (pos !== -1) {
            positions[keyword] = pos;
        }
    });

    // 没有匹配到任何的keyword，直接退出
    if (Object.keys(positions).length === 0) {
        result.push({
            value: str.substring(position),
            type: 'normal',
        });
        return result;
    }

    while (position < strlen) {
        // tip: keywordsCopy的内容会不断减少
        if (keywordsCopy.length === 0) {
            result.push({
                value: str.substring(position),
                type: 'normal',
            });
            break;
        }

        /** keyword下标最小值 */
        let minPos = str.length;
        let minKeyword = null;
        // 找到最小的pos，这里肯定会匹配到一个keyword
        keywordsCopy.forEach((keyword) => {
            const pos = positions[keyword];
            if (!isUndef(pos) && pos < minPos) {
                minPos = pos;
                minKeyword = keyword;
            }
        });
        // 分割
        if (position < minPos) {
            result.push({
                value: str.substring(position, minPos),
                type: 'normal',
            });
        }
        // 重新指定下次pos
        position = minPos + minKeyword.length;
        // 重新搜索minKeyword所对应的pos
        const newPos = str.indexOf(minKeyword, position);
        if (newPos === -1) {
            keywordsCopy.splice(keywordsCopy.indexOf(minKeyword), 1);
        } else {
            positions[minKeyword] = newPos;
        }
        result.push({
            value: minKeyword,
            type: 'highlight',
        });
    }

    return result;
}

/**
 * @param question
 * @param keywords
 * @return 没有满足的结果时返回undefined
 */
export function formatAnswer(answer, keywords) {
    const a = [];

    // 格式化answer
    if (typeof answer === 'string') {
        const content = answer.replace(/[\r\n]/g, '</p>');
        const arr = content.split('</p>');
        arr.forEach((item, index) => {
            const temp = {
                type: 'text',
                value: item,
            };
            a.push(temp);
        });
    }

    // 每个文本中有多少的keyword
    const aValidKeywordsArray = a.filter((part) => part.type === 'text').map((part) => {
        const answer = part.value;
        return keywords.filter((keyword) => answer.indexOf(keyword) !== -1);
    });

    // 所有出现的keyword
    const map = {};
    for (let i = 0, len = aValidKeywordsArray.length; i < len; i++) {
        aValidKeywordsArray[i].forEach((keyword) => {
            map[keyword] = 1;
        });
    }
    // 不满足所有的keyword条件
    if (Object.keys(map).length < keywords.length) {
        return;
    }

    return a.map((part) => {
        if (part.type !== 'text') {
            return part;
        }
        let value = '';
        // 如果part.value是一个数组的话
        if (typeof part.value === 'string') {
            value = part.value;
        } else {
            part.value.forEach((p) => {
                value += p.value;
            });
        }
        // 处理text
        return {
            type: 'text',
            value: split(value, keywords),
        };
    });
}
